struct MyOpaque {
    int x;
    bool x_has_value = false;
    int y;
    bool y_has_value = false;
  };

  auto my_component = ecs.component<MyOpaque>();
  my_component.opaque(ecs.component().member<int>("a").member<int>("b"))
      .ensure_member([](MyOpaque *data, const char *member) -> void * {
        if (!strcmp(member, "a")) {
          data->x_has_value = true;
          return &data->x;
        } else if (!strcmp(member, "b")) {
          data->y_has_value = true;
          return &data->y;
        }
        return nullptr;
      })
      .get_member([](const MyOpaque *data, const char *member) -> const void * {
        if (!strcmp(member, "a") && data->x_has_value) {
          return &data->x;
        } else if (!strcmp(member, "b") && data->y_has_value) {
          return &data->y;
        }
        return nullptr;
      })
      .serialize([](const flecs::serializer *s, const MyOpaque *data) {
        if (data->x_has_value) {
          s->member("a");
          s->value(data->x);
        }
        if (data->y_has_value) {
          s->member("b");
          s->value(data->y);
        }

        return 0;
      });

  MyOpaque instance;

  flecs::cursor cur(ecs, my_component, &instance);

  cur.push();
  cur.member("a");
  cur.set_int(79);
  std::cout << "a = " << cur.get_int() << std::endl;  // value = 79
  cur.member("b");
  if (cur.get_read_ptr()) {
    std::cout << "b = " << cur.get_int() << std::endl;
  } else {
    std::cout << "b has no value" << std::endl;
  }

  std::cout << ecs.to_json(&instance) << std::endl;
  // output:
  // a = 79
  // b has no value
  // {"a":79}

  using MyMap = std::map<size_t, float>;

  auto float_vector = ecs.vector(flecs::F32);

  auto my_component = ecs.component<MyMap>();
  my_component.opaque(float_vector)
      .count([](const MyMap *m) -> size_t { return 100; })
      .resize([](MyMap *m, size_t size) {})
      .ensure_element([](MyMap *m, size_t elem) -> void * { return &(*m)[elem]; })
      .get_element([](const MyMap *m, size_t elem) -> const void * {
        if (auto it = m->find(elem); it != m->end()) {
          return &it->second;
        } else {
          return nullptr;
        }
      })
      .serialize([](const flecs::serializer *s, const MyMap *m) {
        if (m->empty()) {
          return 0;
        }
        size_t startIndex = 0;
        size_t prevKey = startIndex;
        auto it = m->begin();
        for (size_t i = startIndex; i < it->first; ++i) {
          s->value(0.0);
        }
        s->value(it->second);
        prevKey = it->first;
        for (++it; it != m->end(); ++it) {
          size_t currentKey = it->first;
          for (size_t gapKey = prevKey + 1; gapKey < currentKey; ++gapKey) {
            s->value(0.0);
          }
          s->value(it->second);
          prevKey = currentKey;
        }
        return 0;
      });

  MyMap instance;

  flecs::cursor cur(ecs, my_component, &instance);

  cur.push();
  cur.elem(2);
  cur.set_float(2.25);
  cur.elem(7);
  cur.set_float(7.25);
  cur.elem(10);
  cur.set_float(10.25);

  // try to access non-existing value:
  cur.elem(15); 
  if (!cur.get_read_ptr()) {
    std::cout << "Element #15 does not exist" << std::endl;
  } else {
    std::cout << "Element #15 = " << cur.get_float() << std::endl;
  }
  cur.pop();

  std::cout << ecs.to_json(&instance) << std::endl;
// output:
// Element #15 does not exist
// [0, 0, 2.25, 0, 0, 0, 0, 7.25, 0, 0, 10.25]